package top.lixunda.ecommerce.server.good.api.controller;

import com.baomidou.mybatisplus.core.metadata.IPage;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.*;
import top.lixunda.commerce.common.core.entity.MessageObject;
import top.lixunda.common.validate.XumValid;
import top.lixunda.ecommerce.server.business.api.entity.dto.PageConvertDTO;
import top.lixunda.ecommerce.server.good.api.entity.db.GoodOrderDO;
import top.lixunda.ecommerce.server.good.api.entity.dto.AdminOrderDetailQueryDTO;
import top.lixunda.ecommerce.server.good.api.entity.dto.GoodOrderInsertDTO;
import top.lixunda.ecommerce.server.good.api.entity.dto.OrderDetailQueryDTO;
import top.lixunda.ecommerce.server.good.api.entity.dto.StoreOrderDetailQueryDTO;
import top.lixunda.ecommerce.server.good.api.entity.vo.OrderConvertVO;
import top.lixunda.ecommerce.server.good.api.entity.db.OrderDetailDO;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
import java.util.Map;

/**
 * @author Xumda
 * @version time:2020/1/10 15:54
 * <p>
 * 订单详情管理
 */
@SuppressWarnings("unused")
@Api("订单详情管理")
@RequestMapping("/order_detail")
public interface IOrderDetailController {

    /**
     * 根据订单id查看订单信息，但api可以查看本人的所有订单
     *
     * @param id 订单id
     * @return 订单详细数据
     */
    @ApiOperation("根据订单id查看订单信息，但api可以查看本人的所有订单")
    @GetMapping("queryOrderDetailById")
    MessageObject<OrderConvertVO> queryOrderDetailById(@RequestParam("id") Integer id);

    /**
     * 根据订单id查看多个订单信息，但api可以查看本人的所有订单, 默认根据时间排序
     *
     * @param ids 订单id
     * @return 订单详细数据
     */
    @ApiOperation("根据订单id查看多个订单信息，但api可以查看本人的所有订单")
    @PostMapping("queryOrderDetailByIds")
    MessageObject<List<OrderConvertVO>> queryOrderDetailByIds(@RequestBody List<Integer> ids);

    /**
     * 分页条件查询
     *
     * @param pageDTO 分页数据和提哦啊见数据
     * @return 订单详细数据列表
     */
    @ApiOperation("分页条件查询")
    @PostMapping("queryOrderDetailPageWrapper")
    MessageObject<IPage<OrderConvertVO>> queryOrderDetailPageWrapper(
            @XumValid @RequestBody PageConvertDTO<GoodOrderDO, OrderDetailDO, OrderDetailQueryDTO> pageDTO);

    /**
     * 店铺调用，根据订单id查看订单信息，但api可以查看本人的所有订单
     *
     * @param id 订单id
     * @return 订单详细数据
     */
    @ApiOperation("店铺调用，根据订单id查看订单信息，但api可以查看本人的所有订单")
    @GetMapping("queryOrderDetailByIdStore")
    MessageObject<OrderConvertVO> queryOrderDetailByIdStore(@RequestParam("id") Integer id);

    /**
     * 店铺调用，根据订单id查看多个订单信息，但api可以查看本人的所有订单, 默认根据时间排序
     *
     * @param ids 订单id
     * @return 订单详细数据
     */
    @ApiOperation("店铺调用，根据订单id查看多个订单信息，但api可以查看本人的所有订单")
    @PostMapping("queryOrderDetailByIdsStore")
    MessageObject<List<OrderConvertVO>> queryOrderDetailByIdsStore(@RequestBody List<Integer> ids);

    /**
     * 店铺调用，分页条件查询
     *
     * @param pageDTO 分页数据和提哦啊见数据
     * @return 订单详细数据列表
     */
    @ApiOperation("店铺调用，分页条件查询")
    @PostMapping("queryOrderDetailPageWrapperStore")
    MessageObject<IPage<OrderConvertVO>> queryOrderDetailPageWrapperStore(
            @XumValid @RequestBody PageConvertDTO<GoodOrderDO, OrderDetailDO, StoreOrderDetailQueryDTO> pageDTO);

    /**
     * 管理员调用，根据订单id查看订单信息，但api可以查看本人的所有订单
     *
     * @param id 订单id
     * @return 订单详细数据
     */
    @ApiOperation("管理员调用，根据订单id查看订单信息，但api可以查看本人的所有订单")
    @GetMapping("queryOrderDetailByIdAdmin")
    MessageObject<OrderConvertVO> queryOrderDetailByIdAdmin(@RequestParam("id") Integer id);

    /**
     * 管理员调用，根据订单id查看多个订单信息，但api可以查看本人的所有订单, 默认根据时间排序
     *
     * @param ids 订单id
     * @return 订单详细数据
     */
    @ApiOperation("管理员调用，根据订单id查看多个订单信息，但api可以查看本人的所有订单")
    @PostMapping("queryOrderDetailByIdsAdmin")
    MessageObject<List<OrderConvertVO>> queryOrderDetailByIdsAdmin(@RequestBody List<Integer> ids);

    /**
     * 管理员调用，分页条件查询
     *
     * @param pageDTO 分页数据和提哦啊见数据
     * @return 订单详细数据列表
     */
    @ApiOperation("管理员调用，分页条件查询")
    @PostMapping("queryOrderDetailPageWrapperAdmin")
    MessageObject<IPage<OrderConvertVO>> queryOrderDetailPageWrapperAdmin(
            @XumValid @RequestBody PageConvertDTO<GoodOrderDO, OrderDetailDO, AdminOrderDetailQueryDTO> pageDTO);

    /**
     * 用户调用，根据id删除订单
     *
     * @param ids 订单id列表
     * @return 是否删除成功
     */
    @ApiOperation("用户调用，根据id删除订单")
    @PostMapping("removeOrderByIds")
    MessageObject<Boolean> removeOrderByIds(@RequestBody List<Integer> ids);

    /**
     * 店家调用，根据id删除订单
     *
     * @param ids 订单id列表
     * @return 是否删除成功
     */
    @ApiOperation("店家调用，根据id删除订单")
    @PostMapping("removeOrderByIdsStore")
    MessageObject<Boolean> removeOrderByIdsStore(@RequestBody List<Integer> ids);

    /**
     * 购买商品，生成订单
     *
     * @param goodOrderInsertDTO DTO
     * @return OrderConvertVO
     */
    @ApiOperation("购买商品，生成订单")
    @PostMapping("insertGoodOrderDTO")
    MessageObject<OrderConvertVO> insertGoodOrderDTO(
            @XumValid @RequestBody GoodOrderInsertDTO goodOrderInsertDTO);

    /**
     * 根据id取消订单
     *
     * @param ids 取消订单的订单编号
     * @return 取消的订单数据
     */
    @ApiOperation("根据id取消订单")
    @PostMapping("cancelOrderByIds")
    MessageObject<List<OrderConvertVO>> cancelOrderByIds(@RequestBody List<Integer> ids);

    /**
     * 订单支付
     *
     * @param id       订单id
     * @param returnUrl 支付返回地址
     * @param response HttpServletResponse
     * @throws IOException 通过Response向前端写数据异常
     */
    @ApiOperation("订单支付")
    @GetMapping("payOrderById")
    void payOrderById(@RequestParam("id") Integer id, @RequestParam("returnUrl") String returnUrl,
                      HttpServletResponse response) throws IOException;

    /**
     * 订单支付通知消息
     *
     * @param map 参数
     * @param request HttpServletRequest
     * @return 是否成功
     */
    @ApiOperation("购买商品，生成订单")
    @PostMapping("payOrderNotifyCallback")
    MessageObject<Boolean> payOrderNotifyCallback(
            Map<String, String> map, HttpServletRequest request);

    /**
     * 用户调用，申请退款，申请后由店家验证退款
     *
     * @param orderId 订单编号
     * @param message 申请理由
     * @return 是否申请成功
     */
    @ApiOperation("用户调用，申请退款，申请后由店家验证退款")
    @GetMapping("applyRefundByOrderId")
    MessageObject<Boolean> applyRefundByOrderId(
            @RequestParam("orderId") Integer orderId,
            @RequestParam("message") String message);

    /**
     * 用户调用，根据申请id取消退款申请
     *
     * @param id 退款申请id
     * @return 是否取消成功
     */
    @ApiOperation("用户调用，根据申请id取消退款申请")
    @GetMapping("applyRefundCancelById")
    MessageObject<Boolean> applyRefundCancelById(@RequestParam("id") Integer id);

    /**
     * 用户调用，根据订单id取消退款申请
     *
     * @param orderId 订单id
     * @return 是否取消成功
     */
    @ApiOperation("用户调用，根据申请id取消退款申请")
    @GetMapping("applyRefundCancelByOrderId")
    MessageObject<Boolean> applyRefundCancelByOrderId(@RequestParam("orderId") Integer orderId);

    /**
     * 商家调用，根据订单编号对订单进行退款操作
     *
     * @param id 订单编号
     * @return 是否退款成功
     */
    @ApiOperation("根据订单编号对订单进行退款操作")
    @GetMapping("refundByOrderId")
    MessageObject<Boolean> refundByOrderId(@RequestParam("id") Integer id);

    /**
     * 用户调用，根据订单编号移除订单
     *
     * @param id 订单编号
     * @return 是否移除成功
     */
    @ApiOperation("用户调用，根据订单编号移除订单")
    @GetMapping("removeOrderUserById")
    MessageObject<Boolean> removeOrderUserById(@RequestParam("id") Integer id);

    /**
     * 店铺调用，根据订单编号移除订单
     *
     * @param id 订单编号
     * @return 是否移除成功
     */
    @ApiOperation("店铺调用，根据订单编号移除订单")
    @GetMapping("removeOrderStoreById")
    MessageObject<Boolean> removeOrderStoreById(@RequestParam("id") Integer id);

}
